<?xml version="1.0" encoding="UTF-8"?>
<html>
    <head>
        <link type="text/css" rel="stylesheet" href="./css/template.css" />
        <link type="text/css" rel="stylesheet" href="./css/SyntaxHighlighter.css" />
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <title>Les fichiers .jar</title>
        <script language="javascript" src="./js/shInit.js" />
        <script language="javascript" src="./js/shCore.js" />
        <script language="javascript" src="./js/shBrushCpp.js" />
        <script language="javascript" src="./js/shBrushCSharp.js" />
        <script language="javascript" src="./js/shBrushCss.js" />
        <script language="javascript" src="./js/shBrushDelphi.js" />
        <script language="javascript" src="./js/shBrushJava.js" />
        <script language="javascript" src="./js/shBrushJScript.js" />
        <script language="javascript" src="./js/shBrushPhp.js" />
        <script language="javascript" src="./js/shBrushPython.js" />
        <script language="javascript" src="./js/shBrushRuby.js" />
        <script language="javascript" src="./js/shBrushSql.js" />
        <script language="javascript" src="./js/shBrushVb.js" />
        <script language="javascript" src="./js/shBrushXml.js" />
        <keywords>archive, jar, manifest</keywords>
        <author>Séverin PARENT</author>
    </head>
    <body>
        <div class="chapter">
            <h2>Introduction</h2>
            <p>
                Le format d’archive Java, JAR vous permet de regrouper plusieurs fichiers en un seul grâce à une compression de type ZIP.
                <br />
                De manière générale un fichier JAR contiendra les fichiers .class ainsi que les ressources auxiliaires associées
				à l’application ou à l’applet.
                <br />
                L’intérêt ne s’arrète évidemment pas la puisque ce format offre de nombreuses fonctionalités comme
				par exemple la possibilité d’éxécuter (lien vers partie éxécution)
				simplement, voir automatiquement votre application.
            </p>
            <p>Voici les principaux avantages qu’apportent les fichiers JAR :</p>
            <ul>
                <p />
                <li>Sécurité : il est possible de signer numériquement le contenu de l’archive.</li>
                <p />
                <li>Rapidité dans les downloads : si votre applet est archivé en JAR, les fichiers class et les ressources associés
					pourront être downloader vers le navigateur avec
					une seule transaction http sans avoir besoin d’ouvrir une nouvelle connexion pour chaque fichier.</li>
                <p />
                <li>Taille réduite : le format JAR permet de compresser les données (format ZIP)</li>
                <p />
                <li>Portabilité : la gestion des fichiers JAR est un standard de la plateforme Java.</li>
                <p />
                <li>Vérrouillage de packages : il est possible de vérrouiller les contenus d’un fichier JAR.</li>
                <p />
                <li>Exécution : le format JAR permet une éxécution facile et rapide des fichiers qu’il contient.</li>
                <p />
                <li>Extension : le format JAR est utilisé par les extensions de la plate forme Java.</li>
            </ul>
            <p>
                Avant de s’intéresser aux fonctionnalités avancées telles que l’éxécution ou la signature d
				’archive nous allons d’abord étudier les principes de bases,
				telle que la création d’un fichier JAR (commandes et options au travers d’un exemple).
                <br />
                Nous verrons ensuite le fonctionnement de l’extraction et de la visualisation de nos archive.
            </p>
            <p>La compréhension du fichier Manifest est indispensable, c’est pourquoi une partie lui sera consacrée avant de nous pencher
				sur l’éxécution d’une application ou d’une applet depuis le format JAR.</p>
        </div>
        <div class="chapter">
            <h2>Création d'un fichier JAR</h2>
            <div class="subChapter">
                <h3>Commandes et options</h3>
                <p>
                    La commande de base pour la crèation d’un fichier JAR est très simple :
                    <br />
                </p>
                <div class="quote">
                    <span class="cmd_line_lvl">$&gt;</span>
                    <span class="cmd_line">jar cf nom-jar noms-fichiers</span>
                    <br />
                </div>
                <p>
                    Voyons les arguments et les options de cette commande en détail :
                    <br />
                    Tout d’abord " nom-jar " correspond au nom qui sera donné a votre archive, l’option " cf "
					indique que l’on désire que notre archive soir crée dans un fichier, en l’occurrence le
					fichier " nom-jar ".
                    <br />
                    L’option " c " correspond à la crétion et " f " au fichier, leur ordre
					importe peu, cependant il est impératif que ces options ne soient pas séparées par un espace.
                </p>
                <p>L’argument " noms-fichiers " est la liste des fichiers qui seront archivés.
					Il peut y avoir un ou plusieurs fichiers, dans le deuxième cas, ces derniers seront
					séparés par des espaces. Dans le cas de dossiers, le contenu de ces derniers sera ajouté
					à l’archive.Cette commande va donc crée une archive de nos fichiers dans le dossier courant.</p>
                <p>Voyons maintenant quelques options que vous pouvez ajouter à votre commande :</p>
                <ul>
                    <p />
                    <li>-v : crée une sortie indiquant le nom de chaque fichier ajouté à notre archive</li>
                    <p />
                    <li>-0 : utilisé pour que les fichiers ne soient pas compréssés</li>
                    <p />
                    <li>-m : indique que l’on ne désire pas la création d’un fichier Manifest par défaut, nous aborderons plus en d
						étail les fichiers manifest ultérieurement dans cet article</li>
                    <p />
                    <li>-c : permet de ne pas garder l’arborescence des fichiers lorque l’on archive des dossiers</li>
                </ul>
                <p>Afin de mieux comprendre cet outil, nous allons nous intéresser à un exemple</p>
                <center>
                    <b>Exemple</b>
                </center>
                <br />
                <p>Prenons une application Helloworld (original n’est-ce pas ?), organisé de cette manière :</p>
                <br />
                <center>
                    <img src="./images/exemple.bmp" />
                </center>
                <p>Notre dossier Helloworld contient un fichier class Helloworld.class ainsi qu’on dossier avec les images utilisés par l’
					application.</p>
                <p>Pour archiver ces fichiers vous pouvez utiliser la commande :</p>
                <div class="quote">
                    <span class="cmd_line_lvl">$&gt;</span>
                    <span class="cmd_line">jar cvf Helloworld.jar Helloworld.class images</span>
                    <br />
                </div>
                <p>
                    Un fichier JAR Helloworld sera alors crée dans le fichier courant, contenant notre .class ainsi que le dossier image et son contenu.
                    <br />
                    L’option " v " nous a permis d’avoir cet affichage :
                </p>
                <p>
                    adding: Helloworld.class (in=25) (out=20) (deflated 20%)
                    <br />
                    adding: images/ (in=0) (out=0) (stored 0%)
                    <br />
                    adding: images/bouton.gif (in=128) (out=130) (deflated -1%)
                    <br />
                    adding: images/bonhomme.gif (in=153) (out=156) (deflated -1%)
                    <br />
                </p>
                <p>L’on peut voir que notre fichier est compressé, en effet l’option par défaut réalise la comprésion, il
					faut donc utilisé la commande suivante pour ne pas compresser notre archive :</p>
                <div class="quote">
                    <span class="cmd_line_lvl">$&gt;</span>
                    <span class="cmd_line">jar -cvf Helloworld.jar Helloworld.class images</span>
                    <br />
                </div>
                <p>Il est possible d’utiliser le symbole " * " pour archiver la totailté du repertoire courant comme la commande suivante :</p>
                <div class="quote">
                    <span class="cmd_line_lvl">$&gt;</span>
                    <span class="cmd_line">jar -cvf Helloworld.jar *</span>
                    <br />
                </div>
                <p>Si vous desiré mettre tous vos fichiers au même niveau dans votre archive, vous pouvez utiliser l’option -c :</p>
                <div class="quote">
                    <span class="cmd_line_lvl">$&gt;</span>
                    <span class="cmd_line">jar cf Helloworld.jar Helloworld.class -c images</span>
                    <br />
                </div>
                <p>Le contenu de votre fichier sera alors :</p>
                <p>
                    META-INF/MANIFEST.MF
                    <br />
                    Helloworld.class
                    <br />
                    bouton.gif
                    <br />
                    bonhomme.gif
                    <br />
                </p>
                <p>La même commande sans l’option " -c " donnera :</p>
                <p>
                    META-INF/MANIFEST.MF
                    <br />
                    Helloworld.class
                    <br />
                    images/bouton.gif
                    <br />
                    images /bonhomme.gif
                </p>
            </div>
        </div>
        <div class="chapter">
            <h2>Extraction et visualisation</h2>
            <div class="subChapter">
                <h3>Extraction</h3>
                <p>La commande de base pour l’extraction d’un fichier JAR est la suivante :</p>
                <div class="quote">
                    <span class="cmd_line_lvl">$&gt;</span>
                    <span class="cmd_line">jar xf nom-jar [noms-fichiers]</span>
                    <br />
                </div>
                <p>
                    nom-jar est le fichier JAR que nous voulons extraire, l’option " x " permet de réaliser l’extraction, et l’option " f
					" indique que le nom du fichier à extraire va être passé en ligne ligne de commande.
                    <br />
                    L’argument " noms-fichiers " permet quant à lui de désigner les fichiers que l’on désire extraire, si jamais il n
					’est pas utilisé, la totailté de l’archive est alors extraite.
                </p>
                <p>Les fichiers sont copiés depuis l’archive vers le répertoire courant, l’archive reste inchangé, cependant s
					’il existe deja des fichiers portant le même nom dans le répertoire, ces derniers seront éffacés.</p>
                <p>Par exemple, si nous désirons extraire notre fichier Helloworld.jar :</p>
                <div class="quote">
                    <span class="cmd_line_lvl">$&gt;</span>
                    <span class="cmd_line">jar xf Helloworld.jar Helloworld.class images/bouton.gif images/bonhomme.gif</span>
                    <br />
                </div>
                <p>Le fichier " Helloworld.class " est copié, le répertoire " images " est crée et les fichiers " bouton.gif, bonhomme.gif "
					sont copiés dedans.</p>
            </div>
            <div class="subChapter">
                <h3>Visualisation</h3>
                <p>La commande de base pour la visualisation d’un fichier JAR est la suivante :</p>
                <div class="quote">
                    <span class="cmd_line_lvl">$&gt;</span>
                    <span class="cmd_line">jar tf nom-jar</span>
                    <br />
                </div>
                <p>L’option " t " indique que nous voulons visualiser le contenu de notre archive, " f " indique que le nom de l’archive sera pass
					é en argument et bien sur " nom-jar " est le nom ou le chemin complet du fichier que l’on veut voir.</p>
                <p>Pour notre exemple cette commande affichera :</p>
                <p>
                    META-INF/MANIFEST.MF
                    <br />
                    Helloworld.class
                    <br />
                    images/
                    <br />
                    images/bouton.gif
                    <br />
                    images /bonhomme.gif
                    <br />
                </p>
                <p>L’option " v " permettra d’obtenir des informations supplémentaires :</p>
                <p>
                    256 Wed May 5 15:28:37 PDT 2004 META-INF/MANIFEST.MF
                    <br />
                    20 Wed May 5 15:28:37 PDT 2004 Helloworld.class
                    <br />
                    0 Wed May 5 15:28:37 PDT 2004 images/
                    <br />
                    130 Wed May 5 15:28:37 PDT 2004 images/cross.gif
                    <br />
                    156 Wed May 5 15:28:37 PDT 2004 images/not.gif
                </p>
            </div>
        </div>
        <div class="chapter">
            <h2>Conclusion</h2>
            <p>
                Nous avons donc avec cet article abordé le traitement des fichiers JAR, ils pourront être d’une grande utilité dans le
				processus de vie de vos applications.
                <br />
                Pour toutes informations supplémentaires n’hésitez pas à m’écrire.
            </p>
        </div>
        <div class="chapter">
            <h2>Exécution d’un fichier JAR</h2>
            <p>Maintenant que nous avons vu comment crée nos fichiers JAR, ainsi que les moyens de disposer de certaines de leurs fonctionnalité
				s, nous allons voir comment les éxécuter.</p>
            <p>Prenons le cas d’une application que nous désirons lancer depuis la ligne de commande, la commande est alors la suivante :</p>
            <div class="subChapter">
                <span class="cmd_line_lvl">$&gt;</span>
                <span class="cmd_line">java -jar nom-jar</span>
                <br />
            </div>
            <p>" -jar " indique à l’interpreteur de commande que notre application est archivé.</p>
            <p>" nom-jar " est bien évidemment le nom ou le chemin de notre archive.</p>
            <p>Pour que l’éxecution s’effectue correctement à partir de cette ligne de commande, il faut que le fichier Manifest par
				défaut est été modifié comme vu précedemment.</p>
            <p>Reprenons notre exemple du début de manière à synthétiser la totalité du processus.</p>
            <p>
                Création du fichier Manifest (monManifest.txt):
                <br />
                <b>Main-Class: Helloworld.class</b>
            </p>
            <p>Création de l’archive :</p>
            <div class="subChapter">
                <span class="cmd_line_lvl">$&gt;</span>
                <span class="cmd_line">jar cmf monManifest.txt Helloworld.jar Helloworld.class images</span>
                <br />
            </div>
            <p>Exécution de l’archive:</p>
            <div class="subChapter">
                <span class="cmd_line_lvl">$&gt;</span>
                <span class="cmd_line">java -jar Helloworld.jar</span>
                <br />
            </div>
        </div>
        <div class="chapter">
            <h2>Compréhension du fichier Manifest</h2>
            <p>Les archives JAR offrent de nombreuses fonctionnalités telles que le vérouillage de package, la signature électronique, la
				création d’extension par exemple. Ce que rend cela possible est le fichier Manifest.</p>
            <p>Ce fichier contient des informations à propos du contenu de l’archive et offre donc de nombreuses possibilités. Avant de
				nous y plonger, voyons tout d’abord le contenu du fichier Manifest par défaut qui est crée si vous n’utilisez pas l’option " m ".</p>
            <p>
                En effet quand vous créez une archive JAR un fichier Manifest par défaut y est ajouté.
				Il ne peut y avoir qu’un seul Manifest par archive, son chemin est toujours le suivant :
                <br />
                <b>META-INF/MANIFEST.MF</b>
            </p>
            <p>Le contenu de ce fichier est simple : Manifest-Version: 1.0, car il ne contient pas d’information à propos des autres fichiers, c
				’est information seront rajoutés si vous désirez utilisez les fonctionalités avancés des fichiers JAR.</p>
            <p>Il faut donc ajoutés des informations à ce fichier, nous allons donc nous penchez sur les principales fonctionnalités
				ainsi que les moyens de les mettre en uvre au travers du fichier Manifest.</p>
            <h4>Application</h4>
            <p>
                Si votre fichier contient toutes les données d’une application, pour permettre l’éxécution de cette derni
				ère il faut rajouter l’entête " Main-Class " suivi du nom de la classe:
                <br />
                <b>Main-Class: nom-classe</b>
            </p>
            <h4>Vérouillage de package</h4>
            <p>
                Il est possible d’assurer le vérrouillage de package, pour cela on utilise l’entête " Name " suivi de l’ent
				ête " Sealed " :
                <br />
                <b>
                    Name: mesPackages/premier/
                    <br />
                    Sealed: true
                </b>
            </p>
            <p>L’entête Name prend la valeur du chemin du package, l’entête " Sealed " prend la valeur " true ".
				Ces deux lignes ne sont pas séparées, en effet du moment qu’il n’y a pas de saut de ligne entre deux entêtes, on
				considère qu’ils sont liés, la valeur " true " s’applique donc à " mesPackages/premier/ ".</p>
            <h4>Quelques règles concernant ce fichier</h4>
            <ul>
                <li>La ligne Manifest-Version est toujours la première, l’ordre du reste des entête n’est pas important.</li>
                <li>L’entête Name doit contenir un nom, chemin complet d’un fichier ou une URL complète.</li>
                <li>Un entête non compris est ignoré.</li>
                <li>Les entêtes sont sensibles à la casse.</li>
            </ul>
        </div>
        <div class="chapter">
            <h2>Le Fichier Manifest</h2>
            <p>Lors de la première partie nous avons abordé les différentes options de création d’un fichier JAR, nous
				allons désormais voir plus en profondeur l’option " m " qui permet de traiter le fichier Manifest.</p>
            <p>En effet si l’option " m " n’est pas spécifiée, un fichier META-INF/MANIFEST.MF est alors ajouté à
				notre archive.Il est possible d’utilisé les fonctions avancés de nos fichiers JAR, comme le vérrouillage de package, en modifiant ce
				fichier :</p>
            <div class="subChapter">
                <span class="cmd_line_lvl">$&gt;</span>
                <span class="cmd_line">jar cmf fichier-manifest nom-jar noms-fichiers</span>
                <br />
            </div>
            <p>
                Le principe de cette commande est le suivant :
                <br />
                Un fichier texte contenant les informations que l’on désire ajouté au fichier Manifest par défaut doit avoir pré
				alablement été crée, il s’agit de l’argument " fichier-manifest ", cette commande va donc lors de la crétion de notre archive
				ajouté notre fichier texte au fichier par défaut.
                <br />
                Les autres options et argument de cette commande sont détaillés dans la partie Création d’un fichier JAR (lien)
            </p>
            <p>Prenons comme exemple le vérrouillage d’un package.</p>
            <p>Nous possédons 2 packages que nous désirons verrouiller :</p>
            mesPackages/premier/
            <br />
            mesPackages/second/
            <p>De manière à effectuer cette tâche nous devons écrire un fichier texte " package " contenant les lignes suivantes :</p>
            <p>
                Name: mesPackages/premier/
                <br />
                Sealed: true
            </p>
            <p>
                Name: mesPackages/premier/
                <br />
                Sealed: true
            </p>
            <p>
                Notre fichier doit impérativement se terminer par une nouvelle ligne ou un retour, de manière à être intégr
				és dans le fichier par défaut sans problèmes.
                <br />
                Il n’est pas nécessaire d’écrire la totalité du fichier Manifest puisque notre texte sera ajouté au
				fichier par défaut.
            </p>
            <p>La commande pour crée notre archive en modifiant le fichier Manifest avec notre fichier " package " sera la suivante :</p>
            <div class="subChapter">
                <span class="cmd_line_lvl">$&gt;</span>
                <span class="cmd_line">jar cmf package nom-jar noms-fichiers</span>
                <br />
            </div>
            <p>Le fichier Manifest de notre archive prendra donc cette forme :</p>
            <p>Manifest-Version: 1.0</p>
            <p>
                Name: mesPackages/premier/
                <br />
                Sealed: true
            </p>
            <p>
                Name: mesPackages/premier/
                <br />
                Sealed: true
            </p>
        </div>
    </body>
</html>

